from flask import jsonify
import json
import copy


def success(data):
    '''
    操作成功
    :param data:
    :return:
    '''
    return jsonify({
        "code": 200,
        "message": "操作成功",
        "data": serialize(data)
    })


def page_success(total, data):
    '''
    分页成功
    :param data:
    :return:
    '''
    return jsonify({
        "code": 200,
        "total": total,
        "message": "操作成功",
        "rows": serialize(data)
    })


def snake_to_camel(snake_str):
    """
    将下划线命名转换为驼峰命名
    :param snake_str: 下划线命名字符串
    :return: 驼峰命名字符串
    """
    components = snake_str.split('_')
    return components[0] + ''.join(x.title() for x in components[1:])


def serialize(data):
    '''
    通用的序列化函数，用于将对象或列表转换为 JSON 可序列化的格式。
    支持 SQLAlchemy 模型和列表。
    :param data: 需要序列化的数据，可以是单个对象或列表
    :return: 经过处理的 JSON 格式的数据
    '''
    # 如果是列表，递归处理每个元素
    if isinstance(data, list):
        return [serialize(item) for item in data]

    # 如果是 SQLAlchemy 模型实例，则自动提取模型的字段并转化为字典
    if hasattr(data, '__table__'):  # 判断是否是 SQLAlchemy 模型实例
        fields = {}
        for column in data.__table__.columns:
            value = getattr(data, column.name)
            fields[column.name] = value
        return fields

    # 如果是字典，也递归处理其中的每个值
    if isinstance(data, dict):
        return {key: serialize(value) for key, value in data.items()}

    # 否则返回原始数据
    return data


class JsonObject:
    def __init__(self, **kwargs):
        # 动态设置属性，将字典中的键值对映射到对象属性
        for key, value in kwargs.items():
            setattr(self, key, value)

    def __repr__(self):
        # 打印对象时，显示为类名和属性
        return f"{self.__class__.__name__}({self.__dict__})"


class JsonConverter:
    @staticmethod
    def dict_to_object(data, cls):
        """
        将字典数据转换为自定义对象。

        :param data: 字典数据
        :param cls: 目标类，用于转换的自定义类
        :return: 转换后的对象
        """
        if isinstance(data, dict):
            return cls(**data)
        else:
            print("传入的数据不是字典")
            return None

    @staticmethod
    def object_to_dict(obj):
        """
        将对象转换为字典。

        :param obj: 需要转换的对象
        :return: 字典
        """
        if hasattr(obj, 'to_json'):
            return obj.to_json()
        else:
            print("无法转换对象为字典")
            return None

    @staticmethod
    def object_to_json(obj):
        """
        将对象转换为 JSON 字符串。

        :param obj: 需要转换的对象
        :return: JSON 字符串
        """
        try:
            return json.dumps(obj.to_json(), indent=4)
        except TypeError as e:
            print(f"对象转换为 JSON 失败: {e}")
            return None


class BeanUtils:
    @staticmethod
    def copy(source, target):
        """
        将 source 对象的属性复制到 target 对象中。

        :param source: 源对象
        :param target: 目标对象
        """
        if not source or not target:
            raise ValueError("source 和 target 不能为空")

        # 遍历 source 对象的所有属性
        for key, value in source.items():
            # 如果 target 对象中也有相同的属性名称
            if hasattr(target, key):
                setattr(target, key, value)

    @staticmethod
    def deep_copy(source, target):
        """
        深拷贝 source 对象的属性到 target 对象中。适合需要递归复制嵌套对象的情况。

        :param source: 源对象
        :param target: 目标对象
        """
        if not source or not target:
            raise ValueError("source 和 target 不能为空")

        # 遍历 source 对象的所有属性
        for key, value in source.__dict__.items():
            # 如果 target 对象中也有相同的属性名称
            if hasattr(target, key):
                setattr(target, key, copy.deepcopy(value))
